Създаване на Pandas DataFrame: Задълбочено изследване на инициализацията на структурата на данните

Добре дошли в света на манипулирането на данни с Python! В основата на почти всяка задача за анализ на данни се крие библиотеката Pandas, а нейният крайъгълен камък е DataFrame. Мислете за DataFrame като за интелигентна, мощна и гъвкава версия на електронна таблица или таблица на база данни, която живее точно във вашата Python среда. Това е основният инструмент за почистване, трансформиране, анализиране и визуализиране на данни. Но преди да можете да извършите някаква магия с данните, първо трябва да овладеете изкуството на създаване на DataFrame. Начинът, по който инициализирате тази основна структура от данни, може да подготви сцената за целия ви анализ.

Това изчерпателно ръководство е предназначено за глобална аудитория от амбициозни и практикуващи анализатори на данни, учени и инженери. Ще проучим най-често срещаните и мощни методи за създаване на Pandas DataFrames от нулата. Независимо дали данните ви са в речник, списък, NumPy масив или друг формат, тази статия ще ви предостави знанията и практическите примери за инициализиране на вашите DataFrames с увереност и ефективност. Нека изградим нашата основа.

Какво точно е Pandas DataFrame?

Преди да започнем да строим, нека изясним какво конструираме. Pandas DataFrame е двуизмерна, променлива по размер и потенциално хетерогенна таблична структура от данни. Нека разбием това:

• Двуизмерен: Има редове и колони, точно като електронна таблица.
• Променлив по размер: Можете да добавяте или премахвате редове и колони, след като DataFrame е създаден.
• Хетерогенен: Колоните могат да имат различни типове данни. Например, една колона може да съдържа числа (цели числа или числа с плаваща запетая), друга може да съдържа текст (низове), а трета може да съдържа дати или булеви стойности (True/False).

DataFrame има три основни компонента:

1. Данните: Действителните стойности, съдържащи се в структурата, организирани в редове и колони.
2. Индексът: Етикетите за редовете. Ако не предоставите индекс, Pandas създава такъв по подразбиране, започвайки от 0. Индексът предоставя мощен начин за достъп и подравняване на данни.
3. Колоните: Етикетите за колоните. Те са от решаващо значение за достъп до конкретни серии от данни в рамките на DataFrame.

Разбирането на тази структура е от ключово значение за разбирането как да създавате и манипулирате DataFrames ефективно.

Основата: Импортиране на Pandas

Първо най-важното. За да използвате Pandas, трябва да импортирате библиотеката във вашия Python скрипт или notebook. Универсално приетата конвенция, следвана от професионалисти по целия свят, е да я импортирате с псевдонима pd. Този прост псевдоним прави вашия код по-четлив и сбит.

import pandas as pd
import numpy as np # Често се използва заедно с Pandas, така че ще го импортираме и него.

С този единствен ред вие отключихте пълната сила на библиотеката Pandas. Сега нека преминем към същността на това ръководство: създаване на DataFrames.

Основни методи за създаване: От прости до сложни

Конструкторът pd.DataFrame() е невероятно гъвкав. Той може да приема много различни типове входни данни. Сега ще проучим най-важните методи, като преминем от най-често срещаните към по-специализирани случаи.

1. Създаване на DataFrame от речник на списъци или масиви

Това е може би най-често срещаният и интуитивен метод за създаване на DataFrame. Започвате с Python речник, където ключовете ще станат имената на колоните, а стойностите ще бъдат списъци (или NumPy масиви, или Pandas Series), съдържащи данните за всяка колона.

Как работи: Pandas съпоставя всеки ключ от речника със заглавие на колона и всеки списък със стойности с редовете на тази колона. Критично изискване тук е, че всички списъци трябва да имат еднаква дължина, тъй като всеки списък представлява пълна колона от данни.

Пример:

Нека създадем DataFrame, съдържащ информация за различни градове по света.

# Данни, организирани по колони city_data = { 'City': ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'], 'Country': ['Japan', 'India', 'China', 'Brazil', 'India'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } # Създаване на DataFrame df_from_dict = pd.DataFrame(city_data) print(df_from_dict)

Резултат:

         City Country  Population_Millions  Is_Coastal
0       Tokyo   Japan                 37.3        True
1       Delhi   India                 32.0       False
2    Shanghai   China                 28.5        True
3   São Paulo  Brazil                 22.4       False
4      Mumbai   India                 20.9        True

Основен извод: Този метод е идеален, когато данните ви са естествено организирани по функция или категория. Той е чист, четлив и директно превежда структурата на вашия речник в табличен формат.

2. Създаване на DataFrame от списък на речници

Алтернативен и също толкова мощен метод е да използвате списък, където всеки елемент е речник. В тази структура всеки речник представлява един ред, а неговите ключове представляват имената на колоните за данните на този ред.

Как работи: Pandas итерира през списъка. За всеки речник той създава нов ред. Ключовете на речника се използват за определяне на колоните. Този метод е невероятно гъвкав, защото ако в речника липсва ключ, Pandas автоматично ще запълни тази клетка в съответния ред с NaN (Not a Number), което е стандартният маркер за липсващи данни в Pandas.

Пример:

Нека представим същите данни за града, но този път структурирани като списък от записи.

# Данни, организирани по ред (запис) records_data = [ {'City': 'Tokyo', 'Country': 'Japan', 'Population_Millions': 37.3, 'Is_Coastal': True}, {'City': 'Delhi', 'Country': 'India', 'Population_Millions': 32.0, 'Is_Coastal': False}, {'City': 'Shanghai', 'Country': 'China', 'Population_Millions': 28.5}, {'City': 'São Paulo', 'Country': 'Brazil', 'Population_Millions': 22.4, 'Is_Coastal': False}, {'City': 'Cairo', 'Country': 'Egypt', 'Timezone': 'EET'} # Забележете различната структура ] # Създаване на DataFrame df_from_list_of_dicts = pd.DataFrame(records_data) print(df_from_list_of_dicts)

Резултат:

         City Country  Population_Millions  Is_Coastal Timezone
0       Tokyo   Japan                 37.3        True      NaN
1       Delhi   India                 32.0       False      NaN
2    Shanghai   China                 28.5         NaN      NaN
3   São Paulo  Brazil                 22.4       False      NaN
4       Cairo   Egypt                  NaN         NaN      EET

Забележете как Pandas се справи с несъответствията грациозно. Стойността 'Is_Coastal' за Шанхай е NaN, защото липсваше в неговия речник. За Кайро беше създадена нова колона 'Timezone', с NaN за всички други градове. Това го прави отличен избор за работа с полуструктурирани данни, като например JSON отговори от API.

Основен извод: Използвайте този метод, когато данните ви идват като серия от записи или наблюдения. Той е надежден при обработката на липсващи данни и вариации в структурата на записите.

3. Създаване на DataFrame от NumPy масив

За тези, които работят в научни изчисления, машинно обучение или всяка област, включваща тежки числени операции, данните често произхождат от NumPy масиви. Pandas е изграден върху NumPy, което прави интеграцията между двете безпроблемна и високоефективна.

Как работи: Предавате 2D NumPy масив на конструктора pd.DataFrame(). По подразбиране Pandas ще създаде индекси и колони, базирани на цели числа. Въпреки това, можете (и трябва) да предоставите смислени етикети, като използвате параметрите index и columns.

Пример:

Нека създадем DataFrame от произволно генериран 5x4 NumPy масив, представляващ показания на сензори във времето.

# Създаване на 5x4 NumPy масив със случайни данни data_np = np.random.rand(5, 4) # Дефиниране на етикети на колони и индекси columns = ['Sensor_A', 'Sensor_B', 'Sensor_C', 'Sensor_D'] index = pd.to_datetime(['2023-10-27 10:00', '2023-10-27 10:01', '2023-10-27 10:02', '2023-10-27 10:03', '2023-10-27 10:04']) # Създаване на DataFrame df_from_numpy = pd.DataFrame(data=data_np, index=index, columns=columns) print(df_from_numpy)

Резултат (вашите случайни числа ще се различават):

                           Sensor_A  Sensor_B  Sensor_C  Sensor_D
2023-10-27 10:00:00  0.123456  0.987654  0.555555  0.111111
2023-10-27 10:01:00  0.234567  0.876543  0.666666  0.222222
2023-10-27 10:02:00  0.345678  0.765432  0.777777  0.333333
2023-10-27 10:03:00  0.456789  0.654321  0.888888  0.444444
2023-10-27 10:04:00  0.567890  0.543210  0.999999  0.555555

В този пример също така въведохме мощна функция: използване на DatetimeIndex за данни от времеви редове, което отключва огромен набор от възможности за анализ, базирани на времето, в Pandas.

Основен извод: Това е най-паметно-ефективният метод за създаване на DataFrame от хомогенни числени данни. Това е стандартният избор при взаимодействие с библиотеки като NumPy, Scikit-learn или TensorFlow.

4. Създаване на DataFrame от списък на списъци

Този метод е концептуално подобен на създаването от NumPy масив, но използва стандартни Python списъци. Това е лесен начин за конвертиране на таблични данни, съхранени във вложен списъчен формат.

Как работи: Предоставяте списък, където всеки вътрешен списък представлява ред от данни. Както при NumPy масивите, силно се препоръчва да укажете имената на колоните чрез параметъра columns за яснота.

Пример:

# Данни като списък от редове product_data = [ ['P001', 'Laptop', 1200.00, 'Electronics'], ['P002', 'Mouse', 25.50, 'Electronics'], ['P003', 'Desk Chair', 150.75, 'Furniture'], ['P004', 'Keyboard', 75.00, 'Electronics'] ] # Дефиниране на имена на колони column_names = ['ProductID', 'ProductName', 'Price_USD', 'Category'] # Създаване на DataFrame df_from_list_of_lists = pd.DataFrame(product_data, columns=column_names) print(df_from_list_of_lists)

Резултат:

  ProductID ProductName  Price_USD     Category
0      P001      Laptop    1200.00  Electronics
1      P002       Mouse      25.50  Electronics
2      P003  Desk Chair     150.75    Furniture
3      P004    Keyboard      75.00  Electronics

Основен извод: Това е прост и ефективен метод, когато данните ви вече са структурирани като списък от редове, като например при четене от файлов формат, който няма заглавки.

Разширено инициализиране: Персонализиране на вашия DataFrame

Освен предоставянето на необработените данни, конструкторът pd.DataFrame() предлага няколко параметъра за контрол на структурата и свойствата на вашия нов DataFrame от момента на създаването му.

Указване на индекса

Вече видяхме параметъра `index` в действие. Индексът е ключова част от DataFrame, предоставящ етикети за редовете, които се използват за бързи търсения, подравняване на данни и други. Докато Pandas предоставя индекс по подразбиране с числа (0, 1, 2, ...), задаването на смислен индекс може да направи данните ви много по-лесни за работа.

Пример: Нека използваме повторно нашия пример с речник на списъци, но зададем колоната `City` като индекс при създаването.

city_data = { 'Country': ['Japan', 'India', 'China', 'Brazil', 'India'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } city_names = ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'] # Създаване на DataFrame с потребителски индекс df_with_index = pd.DataFrame(city_data, index=city_names) print(df_with_index)

Резултат:

          Country  Population_Millions  Is_Coastal
Tokyo       Japan                 37.3        True
Delhi       India                 32.0       False
Shanghai    China                 28.5        True
São Paulo  Brazil                 22.4       False
Mumbai      India                 20.9        True

Сега можете да получите достъп до данните на реда, като използвате тези смислени етикети, например с df_with_index.loc['Tokyo'].

Контролиране на типовете данни (`dtype`)

Pandas е доста добър в извеждането на типове данни (например, разпознаване на числа, текст и булеви стойности). Въпреки това, понякога трябва да наложите конкретен тип данни за колона, за да осигурите ефективност на паметта или да разрешите конкретни операции. Параметърът `dtype` ви дава този контрол.

Пример: Представете си, че имаме ProductID, които изглеждат като числа, но трябва да се третират като текст (низове).

data = { 'ProductID': [101, 102, 103], 'Stock': [50, 75, 0] } # Създаване на DataFrame, като се посочва dtype за 'ProductID' df_types = pd.DataFrame(data, dtype={'ProductID': str, 'Stock': 'int32'}) print(df_types.dtypes)

Резултат:

ProductID    object
Stock         int32
dtype: object

Забележете, че `str` в Pandas е представен като `object`. Чрез изрично задаване на `dtype` ние предотвратяваме Pandas да третира `ProductID` като число, което може да доведе до неправилни изчисления или проблеми със сортирането в бъдеще. Използването на по-специфични целочислени типове като `int32` вместо стандартния `int64` също може да спести значителна памет при големи набори от данни.

Практически сценарии и най-добри практики

Изборът на правилния метод за създаване зависи от оригиналния формат на вашите данни. Ето просто ръководство за вземане на решения:

• Данните ви са в колони (например, един списък на функция)? Използвайте речник на списъци. Това е естествено решение.
• Данните ви са серия от записи (например, от JSON API)? Използвайте списък на речници. Той се отличава с обработката на липсващи или допълнителни полета в записите.
• Данните ви са числови и в мрежа (например, от научно изчисление)? Използвайте NumPy масив. Това е най-ефективната опция за този случай на употреба.
• Данните ви са в прост табличен формат ред по ред без заглавки? Използвайте списък на списъци и предоставете имената на колоните отделно.

Често срещани клопки, които трябва да се избягват

1. Неравни дължини в речник на списъци: Това е често срещана грешка. Когато създавате DataFrame от речник на списъци, всеки списък трябва да има точно еднакъв брой елементи. Ако не, Pandas ще повдигне `ValueError`. Винаги се уверете, че данните ви за колоните са с еднаква дължина преди създаването.
2. Игнориране на индекса: Разчитането на индекса по подразбиране, базиран на 0, е добре за много случаи, но ако данните ви имат естествен идентификатор (като Product ID, User ID или конкретен Timestamp), задаването му като индекс от самото начало може да опрости вашия код по-късно.
3. Забравяне на типовете данни: Позволяването на Pandas да извежда типове работи през повечето време, но за големи набори от данни или колони със смесени типове, производителността може да пострада. Бъдете проактивни относно задаването на `dtype` за колони, които трябва да се третират като категории, низове или конкретни числени типове, за да спестите памет и да предотвратите грешки.

Отвъд инициализацията: Създаване на DataFrames от файлове

Въпреки че това ръководство се фокусира върху създаването на DataFrames от Python обекти в паметта, от решаващо значение е да знаете, че в по-голямата част от реалните сценарии данните ви ще идват от външен файл. Pandas предоставя набор от силно оптимизирани функции за четене за тази цел, включително:

• pd.read_csv(): За файлове със стойности, разделени със запетая, основният инструмент за импортиране на данни.
• pd.read_excel(): За четене на данни от електронни таблици на Microsoft Excel.
• pd.read_json(): За четене на данни от JSON файлове или низове.
• pd.read_sql(): За четене на резултатите от заявка към база данни директно в DataFrame.
• pd.read_parquet(): За четене от ефективния, ориентиран към колони Parquet файлов формат.

Тези функции са следващата логична стъпка във вашето Pandas пътешествие. Овладяването им ще ви позволи да поглъщате данни от практически всеки източник в мощна DataFrame структура.

Заключение: Вашата основа за овладяване на данните

Pandas DataFrame е централната структура от данни за всяка сериозна работа с данни в Python. Както видяхме, Pandas предлага гъвкав и интуитивен набор от инструменти за инициализиране на тези структури от широк набор от формати. Чрез разбирането как да създадете DataFrame от речници, списъци и NumPy масиви, вие сте изградили солидна основа за вашите проекти за анализ на данни.

Ключът е да изберете метода, който най-добре съответства на оригиналната структура на вашите данни. Това не само прави вашия код по-чист и по-четлив, но и по-ефективен. Оттук сте готови да преминете към вълнуващите задачи за почистване, проучване, трансформиране и визуализиране на данни. Приятно кодиране!